Closes #481

Root cause: PR #471 added lazy caches (ctorDefs/methDefs/fieldDefs/etc.)
in TargetTypeDefinition so wrapper objects are allocated once and shared
across all GetConstructors/GetMethods/etc. calls.  When the F# compiler
invokes these from multiple threads concurrently, the lazies can be forced
concurrently, and the underlying non-thread-safe caches race:

* ILMethodDefs.getmap() / ILTypeDefs.getmap() / ILExportedTypesAndForwarders.getmap()
  used a mutable null-check pattern without synchronisation.  One thread
  sets lmap to a new Dictionary and starts filling it; a second thread sees
  the non-null lmap and reads it while the first is still writing ->
  InvalidOperationException.
* mkCacheInt32 / mkCacheGeneric (binary-reader caches) had the same
  unsynchronised ref-null pattern.
* TxTable<T>.Get wrote to Dictionary<int,T> without a lock; concurrent
  type-resolution calls (txILTypeRef -> txTable.Get) from shared cached
  MethodInfo/ConstructorInfo objects could collide.

Fixes:
* ILMethodDefs / ILTypeDefs / ILExportedTypesAndForwarders: build lmap
  inside lock syncObj so the dictionary is fully populated before any
  reader can see it.  Subsequent calls acquire the lock, check the
  already-set field and return immediately (single branch).
* mkCacheInt32 / mkCacheGeneric: each cache now holds its own lock object
  and protects every TryGetValue/set_Item pair.
* TxTable<T>: backed by ConcurrentDictionary<int, Lazy<T>> so that
  concurrent GetOrAdd calls for the same token race safely, with Lazy<T>
  guaranteeing the factory runs exactly once per token.

Adds a thread-safety regression test: 8 threads × 50 iterations each
calling GetConstructors/GetMethods/GetFields/GetProperties/GetEvents/
GetNestedTypes on the same TargetTypeDefinition simultaneously.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

`mkCacheInt32` and `mkCacheGeneric` were using `Dictionary` + `lock
syncObj`, serializing all cache access including expensive metadata
decode work.

## Changes

- **`mkCacheInt32` / `mkCacheGeneric`**: replaced `Dictionary` + `lock`
with `ConcurrentDictionary` using `TryGetValue` / `TryAdd`. No locks, no
`syncObj`.

```fsharp
let mkCacheInt32 lowMem _infile _nm _sz =
    if lowMem then (fun f x -> f x) else
    let cache = ConcurrentDictionary<int32, _>()
    fun f (idx:int32) ->
        match cache.TryGetValue idx with
        | true, v -> v
        | false, _ ->
            let v = f idx
            cache.TryAdd(idx, v) |> ignore
            cache.[idx]
```

`GetOrAdd(key, factory)` was not usable here — F# type inference cannot
disambiguate it from `GetOrAdd(key, value)` when the value type is an
unconstrained generic. `TryAdd` has no overloads and sidesteps the
issue. On a concurrent cache miss, `f idx` may be computed twice (both
`GetOrAdd` with factory and this pattern share that behaviour per the
.NET docs), which is acceptable since these factories are pure metadata
reads.

<!-- START COPILOT CODING AGENT TIPS -->
---

⌨️ Start Copilot coding agent tasks without leaving your editor —
available in [VS Code](https://gh.io/cca-vs-code-docs), [Visual
Studio](https://gh.io/cca-visual-studio-docs), [JetBrains
IDEs](https://gh.io/cca-jetbrains-docs) and
[Eclipse](https://gh.io/cca-eclipse-docs).

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: sergey-tihon <1197905+sergey-tihon@users.noreply.github.com>